package com.shujia.day10;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.TreeSet;

public class Demo03Map {
    public static void main(String[] args) {
        /*
            TODO Map
                作用： 用于存储键值对数据  K-V 类型
                注意：一个映射不能包含重复的键 K 对Map中Key只能出现一次
                     每个键最多只能映射到一个值  一个Key只能对应一个Value
                 Map接口和Collection接口的不同
                    Map是双列的,Collection是单列的 => 在其他语言中没有该限制
                           当Collection中存储的数据类型是一个键值对类 也可以实现该方法
                            使用TreeSet存储数据也可以实现相关的效果，但是比较麻烦 于是提供了Map
                    Map的键唯一,Collection的子体系Set是唯一的
                    Map集合的数据结构值针对键有效，跟值无关 而 Collection集合的数据结构是针对元素有效
         */

        // 对于TreeSet是可以进行排序的 需要给定排序规则
        TreeSet<MyHashMap.KV<Integer,String>> treeSet = new TreeSet<>();
        treeSet.add(new MyHashMap.KV(1,"one"));
        treeSet.add(new MyHashMap.KV(2,"two"));
        treeSet.add(new MyHashMap.KV(2,"2"));
        System.out.println(treeSet); //实现了去重效果
        /*
            TODO 需求：要求实现 当后面的Key和treeSet对象中保存的Key相同时，实现Value的更新
                    自行完成
         */

        /*
            TODO Map使用
                put 添加数据
                remove(Object key) 删除数据
                void clear()  清空数据
                boolean containsKey(Object key) 查看是否包含某个Key

         */
        HashMap<Integer, String> hashMap = new HashMap<>();
        // 添加数据
        hashMap.put(1,"one");
        hashMap.put(2,"two");
        hashMap.put(2,"2");
        System.out.println(hashMap); // {1=one, 2=2}

        String removeKeyValue = hashMap.remove(1);
        System.out.println("remove:"+removeKeyValue);
        System.out.println(hashMap); // {2=2}

        hashMap.clear();
        hashMap.put(1,"1");
        hashMap.put(2,"2");
        hashMap.put(3,"3");
        hashMap.put(4,"4");
        hashMap.put(5,"5");

        String remove = hashMap.remove(6);
        System.out.println(remove); // null

        /*
            TODO 使用自定义对象进行保存
                1.对象作为Value
         */

        HashMap<Integer, Stu> stuHashMap = new HashMap<>();
        stuHashMap.put(1,new Stu("张三",120,130,140));
        stuHashMap.put(2,new Stu("赵六",120.1,130.1,140.1));
        stuHashMap.put(3,new Stu("王五",60,70,80));
        Stu stu = stuHashMap.remove(2);
        System.out.println(stu.getTotalScore());

        Integer removeKey = 4;
        if(stuHashMap.containsKey(removeKey)){
            Stu stu4 = stuHashMap.remove(removeKey);
            System.out.println(stu4.getTotalScore()); // 防止出现 NullPointerException 空指针异常
        }


    }


}

class MyHashMap{
// 要求传入的Key必须是继承了Comparable的接口或者是实例类
static class KV<K extends Comparable,V> implements Comparable<KV>{
    K k;
    V v;

    public KV(K k, V v) {
        this.k = k;
        this.v = v;
    }

    /*
        TODO 由于Key要求是去重并且只能出现一次  需要拿当前对象的Key和传入的Key进行比较
            由于K是泛型，没有直接给定其类类型，所以只能调用Object方法
                 于是可以使用泛型的类型限定  要求K 是  Comparable的子实现 或者子接口
     */
    @Override
    public int compareTo(KV other) {
        return this.k.compareTo(other.k);
    }

    @Override
    public String toString() {
        return "KV{" +
                "k=" + k.toString() +
                ", v=" + v.toString() +
                '}';
    }
}

}